
def AchievementComplete(self, data):
    ''' 玩家完成自定义成就时触发该事件 '''
    # event_name = AchievementCompleteEvent
    playerId      = data["playerId"]      # str   玩家id
    rootNodeId    = data["rootNodeId"]    # str   所属的页面的根节点成就id
    achievementId = data["achievementId"] # str   达成的成就id
    title         = data["title"]         # str   成就标题
    description   = data["description"]   # str   成就描述
    return

def AddEntity(self, data):
    ''' 服务端侧创建新实体，或实体从存档加载时触发 '''
    # event_name = AddEntityServerEvent
    _id           = data["id"]            # str   实体id
    posX          = data["posX"]          # float 位置x
    posY          = data["posY"]          # float 位置y
    posZ          = data["posZ"]          # float 位置z
    dimensionId   = data["dimensionId"]   # int   实体维度
    isBaby        = data["isBaby"]        # bool  是否为幼儿
    engineTypeStr = data["engineTypeStr"] # str   实体类型，即实体identifier
    itemName      = data["itemName"]      # str   物品identifier（仅当物品实体时存在该字段）
    auxValue      = data["auxValue"]      # int   物品附加值（仅当物品实体时存在该字段）
    return

def AddPlayer(self, data):
    ''' 玩家加入时触发该事件。 '''
    # event_name = AddServerPlayerEvent
    _id     = data["id"]      # str   玩家id
    uid     = data["uid"]     # int/long 仅用于Apollo，玩家的netease uid，玩家的唯一标识
    proxyId = data["proxyId"] # int   仅用于Apollo，当前客户端连接的proxy服务器id
    return

def ChunkAcquireDiscarded(self, data):
    ''' 服务端区块即将被卸载时触发 '''
    # event_name = ChunkAcquireDiscardedServerEvent
    dimension = data["dimension"] # int   区块所在维度
    chunkPosX = data["chunkPosX"] # int   区块的x坐标，对应方块X坐标区间为[x * 16, x * 16 + 15]
    chunkPosZ = data["chunkPosZ"] # int   区块的z坐标，对应方块Z坐标区间为[z * 16, z * 16 + 15]
    entities  = data["entities"]  # list(str) 随区块卸载而从世界移除的实体id的列表。注意事件触发时已经无法获取到这些实体的信息，仅供脚本资源回收用。
    return

def ChunkGenerated(self, data):
    ''' 区块创建完成时触发 '''
    # event_name = ChunkGeneratedServerEvent
    dimension = data["dimension"] # int   该区块所在的维度
    return

def ChunkLoaded(self, data):
    ''' 服务端区块加载完成时 '''
    # event_name = ChunkLoadedServerEvent
    dimension = data["dimension"] # int   区块所在维度
    chunkPosX = data["chunkPosX"] # int   区块的x坐标，对应方块X坐标区间为[x * 16, x * 16 + 15]
    chunkPosZ = data["chunkPosZ"] # int   区块的z坐标，对应方块Z坐标区间为[z * 16, z * 16 + 15]
    return

def LoadAddonsFinish(self, data):
    ''' 客户端mod加载完成时，服务端触发此事件。服务器可以使用此事件，往客户端发送数据给其初始化。 '''
    # event_name = ClientLoadAddonsFinishServerEvent
    playerId = data["playerId"] # str   玩家id
    return

def Command(self, data):
    ''' 玩家请求执行指令时触发 '''
    # event_name = CommandEvent
    entityId = data["entityId"] # str   玩家ID
    command  = data["command"]  # str   指令字符串
    cancel   = data["cancel"]   # bool  是否取消
    return

def DelPlayer(self, data):
    ''' 删除玩家时触发该事件。 '''
    # event_name = DelServerPlayerEvent
    _id = data["id"]  # str   玩家id
    uid = data["uid"] # int/long 玩家的netease uid，玩家的唯一标识
    return

def EntityRemove(self, data):
    ''' 实体被删除时触发 '''
    # event_name = EntityRemoveEvent
    _id = data["id"] # str   实体id
    return

def Explosion(self, data):
    ''' 当发生爆炸时触发。 '''
    # event_name = ExplosionServerEvent
    blocks      = data["blocks"]      # list[[x,y,z,cancel],...] 爆炸导致的被破坏方块坐标(x,y,z)，cancel是一个bool值
    victims     = data["victims"]     # list/None 受伤实体id列表，当该爆炸创建者id为None时，victims也为None
    sourceId    = data["sourceId"]    # str/None 爆炸创建者id
    explodePos  = data["explodePos"]  # list  爆炸位置[x,y,z]
    dimensionId = data["dimensionId"] # int   维度id
    return

def LoadAddonScriptsAfter(self, data):
    ''' 服务器加载完mod时触发 '''
    # event_name = LoadServerAddonScriptsAfter
    # 无参数
    return

def NewOnEntityArea(self, data):
    ''' 通过RegisterEntityAOIEvent注册过AOI事件后，当有实体进入或离开注册感应区域时触发该事件。 '''
    # event_name = NewOnEntityAreaEvent
    name            = data["name"]            # str   注册感应区域名称
    enteredEntities = data["enteredEntities"] # list[str] 进入该感应区域的实体id列表
    leftEntities    = data["leftEntities"]    # list[str] 离开该感应区域的实体id列表
    return

def OnCommandOutput(self, data):
    ''' Command命令执行成功事件 '''
    # event_name = OnCommandOutputServerEvent
    command = data["command"] # str   命令名称
    message = data["message"] # str   命令返回的消息
    return

def OnContainerFillLoottable(self, data):
    ''' 随机奖励箱第一次打开根据loottable生成物品时 '''
    # event_name = OnContainerFillLoottableServerEvent
    loottable = data["loottable"] # str   奖励箱子所读取的loottable的json路径
    playerId  = data["playerId"]  # str   打开奖励箱子的玩家的playerId
    dirty     = data["dirty"]     # bool  默认为False，如果需要修改掉落列表需将该值设为True
    return

def OnLightningLevelChange(self, data):
    ''' 打雷强度发生改变 '''
    # event_name = OnLightningLevelChangeServerEvent
    oldLevel = data["oldLevel"] # float 改变前的打雷强度
    newLevel = data["newLevel"] # float 改变后的打雷强度
    return

def OnLocalLightningLevelChange(self, data):
    ''' 独立维度天气打雷强度发生改变时触发 '''
    # event_name = OnLocalLightningLevelChangeServerEvent
    oldLevel    = data["oldLevel"]    # float 改变前的打雷强度
    newLevel    = data["newLevel"]    # float 改变后的打雷强度
    dimensionId = data["dimensionId"] # int   独立天气维度id
    return

def OnLocalRainLevelChange(self, data):
    ''' 独立维度天气下雨强度发生改变时触发 '''
    # event_name = OnLocalRainLevelChangeServerEvent
    oldLevel    = data["oldLevel"]    # float 改变前的下雨强度
    newLevel    = data["newLevel"]    # float 改变后的下雨强度
    dimensionId = data["dimensionId"] # int   独立天气维度id
    return

def OnRainLevelChange(self, data):
    ''' 下雨强度发生改变 '''
    # event_name = OnRainLevelChangeServerEvent
    oldLevel = data["oldLevel"] # float 改变前的下雨强度
    newLevel = data["newLevel"] # float 改变后的下雨强度
    return

def OnScriptTick(self, data):
    ''' 服务器tick时触发,1秒有30个tick '''
    # event_name = OnScriptTickServer
    # 无参数
    return

def PlaceNeteaseStructureFeature(self, data):
    ''' 首次生成地形时，结构特征即将生成时服务端抛出该事件。 '''
    # event_name = PlaceNeteaseStructureFeatureEvent
    structureName = data["structureName"] # str   结构名称
    posX          = data["x"]             # int   结构坐标最小方块所在的x坐标
    posY          = data["y"]             # int   结构坐标最小方块所在的y坐标
    posZ          = data["z"]             # int   结构坐标最小方块所在的z坐标
    biomeType     = data["biomeType"]     # int   该feature所放置区块的生物群系类型
    biomeName     = data["biomeName"]     # str   该feature所放置区块的生物群系名称
    dimensionId   = data["dimensionId"]   # int   维度id
    cancel        = data["cancel"]        # bool  设置为True时可阻止该结构的放置
    return

def PlayerIntendLeave(self, data):
    ''' 即将删除玩家时触发该事件，此时可以通过各种API获取玩家的当前状态。 '''
    # event_name = PlayerIntendLeaveServerEvent
    playerId = data["playerId"] # str   玩家id
    return

def PlayerJoinMessage(self, data):
    ''' 准备显示“xxx加入游戏”的玩家登录提示文字时服务端抛出的事件。 '''
    # event_name = PlayerJoinMessageEvent
    _id     = data["id"]      # str   玩家实体id
    name    = data["name"]    # str   玩家昵称
    cancel  = data["cancel"]  # bool  是否显示提示文字，允许修改。True：不显示提示
    message = data["message"] # str   玩家加入游戏的提示文字，允许修改
    return

def PlayerLeftMessage(self, data):
    ''' 准备显示“xxx离开游戏”的玩家离开提示文字时服务端抛出的事件。 '''
    # event_name = PlayerLeftMessageServerEvent
    _id     = data["id"]      # str   玩家实体id
    name    = data["name"]    # str   玩家昵称
    cancel  = data["cancel"]  # bool  是否显示提示文字，允许修改。True：不显示提示
    message = data["message"] # str   玩家离开游戏的提示文字，允许修改
    return

def Chat(self, data):
    ''' 玩家发送聊天信息时触发 '''
    # event_name = ServerChatEvent
    username    = data["username"]    # str   玩家名称
    playerId    = data["playerId"]    # str   玩家id
    message     = data["message"]     # str   玩家发送的聊天消息内容
    cancel      = data["cancel"]      # bool  是否取消这个聊天事件，若取消可以设置为True
    bChatById   = data["bChatById"]   # bool  是否把聊天消息发送给指定在线玩家，而不是广播给所有在线玩家，若只发送某些玩家可以设置为True
    bForbid     = data["bForbid"]     # bool  是否禁言，仅apollo可用。true：被禁言，玩家聊天会提示“你已被管理员禁言”。
    toPlayerIds = data["toPlayerIds"] # list(str) 接收聊天消息的玩家id列表，bChatById为True时生效
    return

def PostBlockPattern(self, data):
    ''' 用方块组合生成生物，生成生物之后触发该事件。 '''
    # event_name = ServerPostBlockPatternEvent
    entityId        = data["entityId"]        # str   生成生物的id
    entityGenerated = data["entityGenerated"] # str   生成生物的名字，如"minecraft:pig"
    posX            = data["x"]               # int   方块x坐标
    posY            = data["y"]               # int   方块y坐标
    posZ            = data["z"]               # int   方块z坐标
    dimensionId     = data["dimensionId"]     # int   维度id
    return

def PreBlockPattern(self, data):
    ''' 用方块组合生成生物，在放置最后一个组成方块时触发该事件。 '''
    # event_name = ServerPreBlockPatternEvent
    enable                = data["enable"]                # bool  是否允许继续生成。若设为False，可阻止生成生物
    posX                  = data["x"]                     # int   方块x坐标
    posY                  = data["y"]                     # int   方块y坐标
    posZ                  = data["z"]                     # int   方块z坐标
    dimensionId           = data["dimensionId"]           # int   维度id
    entityWillBeGenerated = data["entityWillBeGenerated"] # str   即将生成生物的名字，如"minecraft:pig"
    return

def SpawnMob(self, data):
    ''' 游戏内自动生成生物，以及使用api生成生物时触发 '''
    # event_name = ServerSpawnMobEvent
    entityId       = data["entityId"]       # str   实体id
    identifier     = data["identifier"]     # str   生成实体的命名空间
    type           = data["type"]           # int   生成实体的类型，参考[EntityType]
    baby           = data["baby"]           # bool  生成怪物是否是幼年怪
    posX           = data["x"]              # float 生成实体坐标x
    posY           = data["y"]              # float 生成实体坐标y
    posZ           = data["z"]              # float 生成实体坐标z
    dimensionId    = data["dimensionId"]    # int   生成实体的维度，默认值为0（0为主世界，1为地狱，2为末地）
    realIdentifier = data["realIdentifier"] # str   生成实体的命名空间，通过MOD API生成的生物在这个参数也能获取到真正的命名空间，而不是以custom开头的
    cancel         = data["cancel"]         # bool  是否取消生成该实体
    return

def ActorHurt(self, data):
    ''' 生物（包括玩家）受伤时触发 '''
    # event_name = ActorHurtServerEvent
    entityId       = data["entityId"]       # str   生物Id
    cause          = data["cause"]          # str   伤害来源，详见Minecraft枚举值文档的[ActorDamageCause]
    damage         = data["damage"]         # int   伤害值（被伤害吸收后的值），不可修改
    damage_f       = data["damage_f"]       # float 伤害值（被伤害吸收后的值），不可修改
    absorbedDamage = data["absorbedDamage"] # int   被伤害吸收效果吸收的伤害值
    return

def ActuallyHurt(self, data):
    ''' 实体实际受到伤害时触发，相比于DamageEvent，该伤害为经过护甲及buff计算后，实际的扣血量 '''
    # event_name = ActuallyHurtServerEvent
    srcId        = data["srcId"]        # str   伤害源id
    projectileId = data["projectileId"] # str   投射物id
    entityId     = data["entityId"]     # str   被伤害id
    damage       = data["damage"]       # int   伤害值（被伤害吸收后的值），允许修改，设置为0则此次造成的伤害为0，若设置数值和原来一样则视为没有修改
    damage_f     = data["damage_f"]     # float 伤害值（被伤害吸收后的值），允许修改，若修改该值，则会覆盖damage的修改效果
    cause        = data["cause"]        # str   伤害来源，详见Minecraft枚举值文档的[ActorDamageCause]
    return

def AddEffect(self, data):
    ''' 实体获得状态效果时 '''
    # event_name = AddEffectServerEvent
    entityId        = data["entityId"]        # str   实体id
    effectName      = data["effectName"]      # str   实体获得状态效果的名字
    effectDuration  = data["effectDuration"]  # int   状态效果的持续时间，单位秒
    effectAmplifier = data["effectAmplifier"] # int   状态效果的放大倍数
    damage          = data["damage"]          # int   状态造成的伤害值（真实扣除生命值的量）。只有持续时间为0时有用
    return

def ChangeSwimState(self, data):
    ''' 实体开始或者结束游泳时 '''
    # event_name = ChangeSwimStateServerEvent
    entityId  = data["entityId"]  # str   实体的唯一ID
    formState = data["formState"] # bool  事件触发前，实体是否在游泳状态
    toState   = data["toState"]   # bool  事件触发后，实体是否在游泳状态
    return

def Damage(self, data):
    ''' 实体受到伤害时触发 '''
    # event_name = DamageEvent
    srcId        = data["srcId"]        # str   伤害源id
    projectileId = data["projectileId"] # str   投射物id
    entityId     = data["entityId"]     # str   被伤害id
    damage       = data["damage"]       # int   伤害值（被伤害吸收前的值），允许修改，设置为0则此次造成的伤害为0
    damage_f     = data["damage_f"]     # float 伤害值（被伤害吸收前的值），不允许修改
    absorption   = data["absorption"]   # int   受到伤害时，扣除黄心前，实体拥有的黄心血量（见[AttrType枚举]
    cause        = data["cause"]        # str   伤害来源，详见Minecraft枚举值文档的[ActorDamageCause]
    knock        = data["knock"]        # bool  是否击退被攻击者，允许修改，设置该值为False则不产生击退
    ignite       = data["ignite"]       # bool  是否点燃被伤害者，允许修改，设置该值为True产生点燃效果，反之亦然
    return

def EntityChangeDimension(self, data):
    ''' 实体维度改变时服务端抛出 '''
    # event_name = EntityChangeDimensionServerEvent
    entityId        = data["entityId"]        # str   实体id
    fromDimensionId = data["fromDimensionId"] # int   维度改变前的维度
    toDimensionId   = data["toDimensionId"]   # int   维度改变后的维度
    fromX           = data["fromX"]           # float 改变前的位置x
    fromY           = data["fromY"]           # float 改变前的位置Y
    fromZ           = data["fromZ"]           # float 改变前的位置Z
    toX             = data["toX"]             # float 改变后的位置x
    toY             = data["toY"]             # float 改变后的位置Y
    toZ             = data["toZ"]             # float 改变后的位置Z
    return

def EntityDefinitions(self, data):
    ''' 生物定义json文件中设置的event触发时同时触发。生物行为变更事件 '''
    # event_name = EntityDefinitionsEventServerEvent
    entityId  = data["entityId"]  # str   生物id
    eventName = data["eventName"] # str   触发的事件名称
    return

def EntityDieLoottable(self, data):
    ''' 生物死亡掉落物品时 '''
    # event_name = EntityDieLoottableServerEvent
    dieEntityId = data["dieEntityId"] # str   死亡实体的entityId
    attacker    = data["attacker"]    # str   伤害来源的entityId
    dirty       = data["dirty"]       # bool  默认为False，如果需要修改掉落列表需将该值设为True
    return

def EntityDroppedItem(self, data):
    ''' 生物扔出物品时触发 '''
    # event_name = EntityDroppedItemServerEvent
    entityId     = data["entityId"]     # str   生物Id
    itemEntityId = data["itemEntityId"] # str   物品实体Id
    return

def EntityEffectDamage(self, data):
    ''' 生物受到状态伤害/回复事件。 '''
    # event_name = EntityEffectDamageServerEvent
    entityId          = data["entityId"]          # str   实体id
    damage            = data["damage"]            # int   伤害值（伤害吸收后实际扣血量），负数表示生命回复量
    attributeBuffType = data["attributeBuffType"] # int   状态类型，参考[AttributeBuffType]
    duration          = data["duration"]          # float 状态持续时间，单位秒（s）
    lifeTimer         = data["lifeTimer"]         # float 状态生命时间，单位秒（s）
    isInstantaneous   = data["isInstantaneous"]   # bool  是否为立即生效状态
    return

def EntityLoadScript(self, data):
    ''' 数据库加载实体自定义数据时触发 '''
    # event_name = EntityLoadScriptEvent
    args = data["args"] # list  该事件的参数为长度为2的list，而非dict，其中list的第一个元素为实体id
    return

def EntityMotionStart(self, data):
    ''' 实体运动器开始事件。实体（包含玩家）添加运动器后，运动器开始运行时触发 '''
    # event_name = EntityMotionStartServerEvent
    motionId = data["motionId"] # int   运动器id
    entityId = data["entityId"] # str   实体id
    return

def EntityMotionStop(self, data):
    ''' 实体运动器停止事件。实体（包含玩家）添加运动器并开始运行后，运动器自动停止时触发 '''
    # event_name = EntityMotionStopServerEvent
    motionId = data["motionId"] # int   运动器id
    entityId = data["entityId"] # str   实体id
    remove   = data["remove"]   # bool  是否移除该运动器，设置为False则保留，默认为True，即运动器停止后自动移除，该参数设置只对非玩家实体有效
    return

def EntityPickupItem(self, data):
    ''' 有minecraft:behavior.pickup_items行为的生物拾取物品时触发该事件，例如村民拾取面包、猪灵拾取金锭 '''
    # event_name = EntityPickupItemServerEvent
    entityId       = data["entityId"]       # str   生物Id
    secondaryActor = data["secondaryActor"] # str   物品给予者id（一般是玩家），如果不存在给予者的话，这里为空字符串
    return

def EntityStartRiding(self, data):
    ''' 当实体骑乘上另一个实体时触发 '''
    # event_name = EntityStartRidingEvent
    _id    = data["id"]     # str   乘骑者实体id
    rideId = data["rideId"] # str   被乘骑者实体id
    return

def EntityStopRiding(self, data):
    ''' 当实体停止骑乘时 '''
    # event_name = EntityStopRidingEvent
    _id                    = data["id"]                     # str   实体id
    rideId                 = data["rideId"]                 # str   坐骑id
    exitFromRider          = data["exitFromRider"]          # bool  是否下坐骑
    entityIsBeingDestroyed = data["entityIsBeingDestroyed"] # bool  坐骑是否将要销毁
    switchingRides         = data["switchingRides"]         # bool  是否换乘坐骑
    cancel                 = data["cancel"]                 # bool  设置为True可以取消（需要与客户端事件一同取消）
    return

def EntityTick(self, data):
    ''' 实体tick时触发。该事件为20帧每秒。需要使用AddEntityTickEventWhiteList添加触发该事件的实体类型白名单。 '''
    # event_name = EntityTickServerEvent
    entityId   = data["entityId"]   # str   实体id
    identifier = data["identifier"] # str   实体identifier
    return

def HealthChangeBefore(self, data):
    ''' 生物生命值发生变化之前触发 '''
    # event_name = HealthChangeBeforeServerEvent
    entityId = data["entityId"] # str   实体id
    _from    = data["from"]     # float 变化前的生命值
    to       = data["to"]       # float 将要变化到的生命值，cancel设置为True时可以取消该变化，但是此参数不变
    byScript = data["byScript"] # bool  是否通过SetAttrValue或SetAttrMaxValue调用产生的变化
    cancel   = data["cancel"]   # bool  是否取消该变化
    return

def HealthChange(self, data):
    ''' 生物生命值发生变化时触发 '''
    # event_name = HealthChangeServerEvent
    entityId = data["entityId"] # str   实体id
    _from    = data["from"]     # float 变化前的生命值
    to       = data["to"]       # float 变化后的生命值
    byScript = data["byScript"] # bool  是否通过SetAttrValue或SetAttrMaxValue调用产生的变化
    return

def MobDie(self, data):
    ''' 实体被玩家杀死时触发 '''
    # event_name = MobDieEvent
    _id      = data["id"]       # str   实体id
    attacker = data["attacker"] # str   伤害来源id
    return

def MobGriefingBlock(self, data):
    ''' 环境生物改变方块时触发，触发的时机与mobgriefing游戏规则影响的行为相同 '''
    # event_name = MobGriefingBlockServerEvent
    cancel      = data["cancel"]      # bool  是否允许触发，默认为False，若设为True，可阻止触发后续物理交互事件
    blockX      = data["blockX"]      # int   方块x坐标
    blockY      = data["blockY"]      # int   方块y坐标
    blockZ      = data["blockZ"]      # int   方块z坐标
    entityId    = data["entityId"]    # str   触发的entity的唯一ID
    blockName   = data["blockName"]   # str   方块的identifier，包含命名空间及名称
    dimensionId = data["dimensionId"] # int   维度id
    return

def OnFireHurt(self, data):
    ''' 生物受到火焰伤害时触发 '''
    # event_name = OnFireHurtEvent
    victim   = data["victim"]   # str   受伤实体id
    src      = data["src"]      # str   火焰创建者id
    fireTime = data["fireTime"] # float 着火时间，单位秒
    cancel   = data["cancel"]   # bool  是否取消此处火焰伤害
    return

def OnGround(self, data):
    ''' 实体着地事件。实体，掉落的物品，点燃的TNT掉落地面时触发 '''
    # event_name = OnGroundServerEvent
    _id = data["id"] # str   实体id
    return

def OnKnockBack(self, data):
    ''' 实体被击退时触发 '''
    # event_name = OnKnockBackServerEvent
    _id = data["id"] # str   实体id
    return

def OnMobHitBlock(self, data):
    ''' 通过OpenMobHitBlockDetection打开方块碰撞检测后，当生物（不包括玩家）碰撞到方块时触发该事件。 '''
    # event_name = OnMobHitBlockServerEvent
    entityId    = data["entityId"]    # str   碰撞到方块的生物Id
    posX        = data["posX"]        # int   碰撞方块x坐标
    posY        = data["posY"]        # int   碰撞方块y坐标
    posZ        = data["posZ"]        # int   碰撞方块z坐标
    blockId     = data["blockId"]     # str   碰撞方块的identifier
    auxValue    = data["auxValue"]    # int   碰撞方块的附加值
    dimensionId = data["dimensionId"] # int   维度id
    return

def OnMobHitMob(self, data):
    ''' 通过OpenPlayerHitMobDetection打开生物碰撞检测后，当生物间（包含玩家）碰撞时触发该事件。注：客户端和服务端分别作碰撞检测，可能两个事件返回的略有差异。 '''
    # event_name = OnMobHitMobServerEvent
    mobId         = data["mobId"]         # str   当前生物的id
    hittedMobList = data["hittedMobList"] # list[str] 当前生物碰撞到的其他所有生物id的list
    return

def ProjectileCritHit(self, data):
    ''' 当抛射物与头部碰撞时触发该事件。注：需调用OpenPlayerCritBox开启玩家爆头后才能触发。 '''
    # event_name = ProjectileCritHitEvent
    _id      = data["id"]       # str   抛射物id
    targetId = data["targetId"] # str   碰撞目标id
    return

def ProjectileDoHitEffect(self, data):
    ''' 当抛射物碰撞时触发该事件 '''
    # event_name = ProjectileDoHitEffectEvent
    _id           = data["id"]            # str   抛射物id
    hitTargetType = data["hitTargetType"] # str   碰撞目标类型,'ENTITY'或是'BLOCK'
    targetId      = data["targetId"]      # str   碰撞目标id
    hitFace       = data["hitFace"]       # int   撞击在方块上的面id，参考[Facing枚举]
    posX          = data["x"]             # float 碰撞x坐标
    posY          = data["y"]             # float 碰撞y坐标
    posZ          = data["z"]             # float 碰撞z坐标
    blockPosX     = data["blockPosX"]     # int   碰撞是方块时，方块x坐标
    blockPosY     = data["blockPosY"]     # int   碰撞是方块时，方块y坐标
    blockPosZ     = data["blockPosZ"]     # int   碰撞是方块时，方块z坐标
    srcId         = data["srcId"]         # str   创建者id
    cancel        = data["cancel"]        # bool  是否取消这个碰撞事件，若取消可以设置为True
    return

def RefreshEffect(self, data):
    ''' 实体身上状态效果更新时触发，更新条件1、新增状态等级较高，更新状态等级及时间；2、新增状态等级不变，时间较长，更新状态持续时间 '''
    # event_name = RefreshEffectServerEvent
    entityId        = data["entityId"]        # str   实体id
    effectName      = data["effectName"]      # str   更新状态效果的名字
    effectDuration  = data["effectDuration"]  # int   更新后状态效果剩余持续时间，单位秒
    effectAmplifier = data["effectAmplifier"] # int   更新后的状态效果放大倍数
    damage          = data["damage"]          # int   状态造成的伤害值，如药水
    return

def RemoveEffect(self, data):
    ''' 实体身上状态效果被移除时 '''
    # event_name = RemoveEffectServerEvent
    entityId        = data["entityId"]        # str   实体id
    effectName      = data["effectName"]      # str   被移除状态效果的名字
    effectDuration  = data["effectDuration"]  # int   被移除状态效果的剩余持续时间，单位秒
    effectAmplifier = data["effectAmplifier"] # int   被移除状态效果的放大倍数
    return

def SpawnProjectile(self, data):
    ''' 抛射物生成时触发 '''
    # event_name = SpawnProjectileServerEvent
    projectileId         = data["projectileId"]         # str   抛射物的实体id
    projectileIdentifier = data["projectileIdentifier"] # str   抛射物的identifier
    spawnerId            = data["spawnerId"]            # str   发射者的实体id，没有发射者时为-1
    return

def StartRiding(self, data):
    ''' 一个实体即将骑乘另外一个实体 '''
    # event_name = StartRidingServerEvent
    cancel   = data["cancel"]   # bool  是否允许触发，默认为False，若设为True，可阻止触发后续的实体交互事件
    actorId  = data["actorId"]  # str   骑乘者的唯一ID
    victimId = data["victimId"] # str   被骑乘实体的唯一ID
    return

def WillAddEffect(self, data):
    ''' 实体即将获得状态效果前 '''
    # event_name = WillAddEffectServerEvent
    entityId        = data["entityId"]        # str   实体id
    effectName      = data["effectName"]      # str   实体获得状态效果的名字
    effectDuration  = data["effectDuration"]  # int   状态效果的持续时间，单位秒
    effectAmplifier = data["effectAmplifier"] # int   状态效果的放大倍数
    cancel          = data["cancel"]          # bool  设置为True可以取消
    damage          = data["damage"]          # int   状态将会造成的伤害值，如药水；需要注意，该值不一定是最终的伤害值，例如被伤害吸收效果扣除。只有持续时间为0时有用
    return

def WillTeleportTo(self, data):
    ''' 实体即将传送或切换维度 '''
    # event_name = WillTeleportToServerEvent
    cancel          = data["cancel"]          # bool  是否允许触发，默认为False，若设为True，可阻止触发后续的传送
    entityId        = data["entityId"]        # str   实体的唯一ID
    fromDimensionId = data["fromDimensionId"] # int   传送前所在的维度
    toDimensionId   = data["toDimensionId"]   # int   传送后的目标维度
    fromX           = data["fromX"]           # int   传送前所在的x坐标
    fromY           = data["fromY"]           # int   传送前所在的y坐标
    fromZ           = data["fromZ"]           # int   传送前所在的z坐标
    toX             = data["toX"]             # int   传送目标地点的x坐标
    toY             = data["toY"]             # int   传送目标地点的y坐标
    toZ             = data["toZ"]             # int   传送目标地点的z坐标
    cause           = data["cause"]           # str   传送理由，详情见MinecraftEnum.EntityTeleportCause
    return

def AddExp(self, data):
    ''' 当玩家增加经验时触发该事件。 '''
    # event_name = AddExpEvent
    _id    = data["id"]     # str   玩家id
    addExp = data["addExp"] # int   增加的经验值
    return

def AddLevel(self, data):
    ''' 当玩家升级时触发该事件。 '''
    # event_name = AddLevelEvent
    _id      = data["id"]       # str   玩家id
    addLevel = data["addLevel"] # int   增加的等级值
    newLevel = data["newLevel"] # int   新的等级
    return

def ChangeLevelUpCost(self, data):
    ''' 获取玩家下一个等级升级经验时，用于重载玩家的升级经验，每个等级在重置之前都只会触发一次 '''
    # event_name = ChangeLevelUpCostServerEvent
    level          = data["level"]          # int   玩家当前等级
    levelUpCostExp = data["levelUpCostExp"] # int   当前等级升级到下个等级需要的经验值，当设置升级经验小于1时会被强制调整到1
    changed        = data["changed"]        # bool  设置为True，重载玩家升级经验才会生效
    return

def DimensionChangeFinish(self, data):
    ''' 玩家维度改变完成后服务端抛出 '''
    # event_name = DimensionChangeFinishServerEvent
    playerId        = data["playerId"]        # str   玩家实体id
    fromDimensionId = data["fromDimensionId"] # int   维度改变前的维度
    toDimensionId   = data["toDimensionId"]   # int   维度改变后的维度
    toPos           = data["toPos"]           # tuple(float,float,float) 改变后的位置x,y,z,其中y值为脚底加上角色的身高值
    return

def DimensionChange(self, data):
    ''' 玩家维度改变时服务端抛出 '''
    # event_name = DimensionChangeServerEvent
    playerId        = data["playerId"]        # str   玩家实体id
    fromDimensionId = data["fromDimensionId"] # int   维度改变前的维度
    toDimensionId   = data["toDimensionId"]   # int   维度改变后的维度
    fromX           = data["fromX"]           # float 改变前的位置x
    fromY           = data["fromY"]           # float 改变前的位置Y
    fromZ           = data["fromZ"]           # float 改变前的位置Z
    toX             = data["toX"]             # float 改变后的位置x
    toY             = data["toY"]             # float 改变后的位置Y
    toZ             = data["toZ"]             # float 改变后的位置Z
    return

def ExtinguishFire(self, data):
    ''' 玩家扑灭火焰时触发。下雨，倒水等方式熄灭火焰不会触发。 '''
    # event_name = ExtinguishFireServerEvent
    pos      = data["pos"]      # tuple(float,float,float) 火焰方块的坐标
    playerId = data["playerId"] # str   玩家id
    cancel   = data["cancel"]   # bool  修改为True时，可阻止玩家扑灭火焰。需要与ExtinguishFireClientEvent一起修改。
    return

def GameTypeChanged(self, data):
    ''' 个人游戏模式发生变化时服务端触发。 '''
    # event_name = GameTypeChangedServerEvent
    playerId    = data["playerId"]    # str   玩家Id，[SetDefaultGameType]
    oldGameType = data["oldGameType"] # int   切换前的游戏模式
    newGameType = data["newGameType"] # int   切换后的游戏模式
    return

def OnPlayerHitBlock(self, data):
    ''' 通过OpenPlayerHitBlockDetection打开方块碰撞检测后，当玩家碰撞到方块时触发该事件。监听玩家着地请使用客户端的OnGroundClientEvent。客户端和服务端分别作碰撞检测，可能两个事件返回的略有差异。 '''
    # event_name = OnPlayerHitBlockServerEvent
    playerId    = data["playerId"]    # str   碰撞到方块的玩家Id
    posX        = data["posX"]        # int   碰撞方块x坐标
    posY        = data["posY"]        # int   碰撞方块y坐标
    posZ        = data["posZ"]        # int   碰撞方块z坐标
    blockId     = data["blockId"]     # str   碰撞方块的identifier
    auxValue    = data["auxValue"]    # int   碰撞方块的附加值
    dimensionId = data["dimensionId"] # int   维度id
    return

def PlayerAttackEntity(self, data):
    ''' 当玩家攻击时触发该事件。 '''
    # event_name = PlayerAttackEntityEvent
    playerId    = data["playerId"]    # str   玩家id
    victimId    = data["victimId"]    # str   受击者id
    damage      = data["damage"]      # int   伤害值：引擎传过来的值是0 允许脚本层修改为其他数
    isValid     = data["isValid"]     # int   脚本是否设置伤害值：1表示是；0 表示否
    cancel      = data["cancel"]      # bool  是否取消该次攻击，默认不取消
    isKnockBack = data["isKnockBack"] # bool  是否支持击退效果，默认支持，当不支持时将屏蔽武器击退附魔效果
    return

def PlayerDie(self, data):
    ''' 当玩家死亡时触发该事件。 '''
    # event_name = PlayerDieEvent
    _id      = data["id"]       # str   玩家id
    attacker = data["attacker"] # str   伤害来源id
    return

def PlayerDoInteract(self, data):
    ''' 玩家与有minecraft:interact组件的生物交互时触发该事件，例如玩家手持空桶对牛挤奶、玩家手持打火石点燃苦力怕 '''
    # event_name = PlayerDoInteractServerEvent
    playerId         = data["playerId"]         # str   玩家id
    interactEntityId = data["interactEntityId"] # str   交互的生物entityId
    return

def PlayerEatFood(self, data):
    ''' 玩家吃下食物时触发 '''
    # event_name = PlayerEatFoodServerEvent
    playerId  = data["playerId"]  # str   玩家Id
    hunger    = data["hunger"]    # int   食物增加的饥饿值，可修改
    nutrition = data["nutrition"] # float 食物的营养价值，回复饱和度 = 食物增加的饥饿值 * 食物的营养价值 * 2，饱和度最大不超过当前饥饿值，可修改
    return

def PlayerHurt(self, data):
    ''' 当玩家受伤害前触发该事件。 '''
    # event_name = PlayerHurtEvent
    _id      = data["id"]       # str   受击玩家id
    attacker = data["attacker"] # str   伤害来源实体id，若没有实体攻击，例如高空坠落，id为-1
    return

def PlayerInteract(self, data):
    ''' 玩家可以与实体交互时。如果是鼠标控制模式，则当准心对着实体时触发。如果是触屏模式，则触发时机与屏幕下方的交互按钮显示的时机相同。玩家真正与实体发生交互的事件见PlayerDoInteractServerEvent '''
    # event_name = PlayerInteractServerEvent
    cancel   = data["cancel"]   # bool  是否取消触发，默认为False，若设为True，可阻止触发后续的实体交互事件
    playerId = data["playerId"] # str   主动与实体互动的玩家的唯一ID
    victimId = data["victimId"] # str   被动的实体的唯一ID
    return

def PlayerRespawn(self, data):
    ''' 玩家复活时触发该事件。 '''
    # event_name = PlayerRespawnEvent
    _id = data["id"] # str   玩家id
    return

def PlayerRespawnFinish(self, data):
    ''' 玩家复活完毕时触发 '''
    # event_name = PlayerRespawnFinishServerEvent
    playerId = data["playerId"] # str   玩家id
    return

def PlayerSleep(self, data):
    ''' 玩家使用床睡觉成功 '''
    # event_name = PlayerSleepServerEvent
    playerId = data["playerId"] # str   玩家id
    return

def PlayerStopSleep(self, data):
    ''' 玩家停止睡觉 '''
    # event_name = PlayerStopSleepServerEvent
    playerId = data["playerId"] # str   玩家id
    return

def PlayerTeleport(self, data):
    ''' 当玩家传送时触发该事件，如：玩家使用末影珍珠或tp指令时。 '''
    # event_name = PlayerTeleportEvent
    _id = data["id"] # str   玩家id
    return

def PlayerTrySleep(self, data):
    ''' 玩家尝试使用床睡觉 '''
    # event_name = PlayerTrySleepServerEvent
    playerId = data["playerId"] # str   玩家id
    cancel   = data["cancel"]   # bool  是否取消（开发者传入）
    return

def PlayerGetExperienceOrb(self, data):
    ''' 玩家获取经验球时触发的事件 '''
    # event_name = ServerPlayerGetExperienceOrbEvent
    playerId        = data["playerId"]        # str   玩家id
    experienceValue = data["experienceValue"] # int   经验球经验值
    cancel          = data["cancel"]          # bool  是否取消（开发者传入）
    return

def StoreBuySucc(self, data):
    ''' 触发时机:玩家游戏内购买商品时服务端抛出的事件 '''
    # event_name = StoreBuySuccServerEvent
    playerId = data["playerId"] # str   购买商品的玩家实体id
    return

def BlockDestroyByLiquid(self, data):
    ''' 方块被水流破坏的事件 '''
    # event_name = BlockDestroyByLiquidServerEvent
    posX       = data["x"]          # int   方块x坐标
    posY       = data["y"]          # int   方块y坐标
    posZ       = data["z"]          # int   方块z坐标
    liquidName = data["liquidName"] # str   流体方块id
    blockName  = data["blockName"]  # str   方块id
    auxValue   = data["auxValue"]   # int   方块附加值
    return

def BlockLiquidStateChangeAfter(self, data):
    ''' 方块转为含水或者脱离含水(流体)后触发 '''
    # event_name = BlockLiquidStateChangeAfterServerEvent
    blockName  = data["blockName"]  # str   方块的identifier，包含命名空间及名称
    auxValue   = data["auxValue"]   # int   方块附加值
    dimension  = data["dimension"]  # int   方块维度
    posX       = data["x"]          # int   方块x坐标
    posY       = data["y"]          # int   方块y坐标
    posZ       = data["z"]          # int   方块z坐标
    turnLiquid = data["turnLiquid"] # bool  是否转为含水，true则转为含水，false则脱离含水
    return

def BlockLiquidStateChange(self, data):
    ''' 方块转为含水或者脱离含水(流体)前触发 '''
    # event_name = BlockLiquidStateChangeServerEvent
    blockName  = data["blockName"]  # str   方块的identifier，包含命名空间及名称
    auxValue   = data["auxValue"]   # int   方块附加值
    dimension  = data["dimension"]  # int   方块维度
    posX       = data["x"]          # int   方块x坐标
    posY       = data["y"]          # int   方块y坐标
    posZ       = data["z"]          # int   方块z坐标
    turnLiquid = data["turnLiquid"] # bool  是否转为含水，true则转为含水，false则脱离含水
    return

def BlockNeighborChanged(self, data):
    ''' 自定义方块周围的方块发生变化时，需要配置netease:neighborchanged_sendto_script，详情请查阅《自定义农作物》文档 '''
    # event_name = BlockNeighborChangedServerEvent
    dimensionId       = data["dimensionId"]       # int   维度
    posX              = data["posX"]              # int   方块x坐标
    posY              = data["posY"]              # int   方块y坐标
    posZ              = data["posZ"]              # int   方块z坐标
    blockName         = data["blockName"]         # str   方块的identifier，包含命名空间及名称
    auxValue          = data["auxValue"]          # int   方块附加值
    neighborPosX      = data["neighborPosX"]      # int   变化方块x坐标
    neighborPosY      = data["neighborPosY"]      # int   变化方块y坐标
    neighborPosZ      = data["neighborPosZ"]      # int   变化方块z坐标
    fromBlockName     = data["fromBlockName"]     # str   方块变化前的identifier，包含命名空间及名称
    fromBlockAuxValue = data["fromBlockAuxValue"] # int   方块变化前附加值
    toBlockName       = data["toBlockName"]       # str   方块变化后的identifier，包含命名空间及名称
    toAuxValue        = data["toAuxValue"]        # int   方块变化后附加值
    return

def BlockRandomTick(self, data):
    ''' 自定义方块配置[netease:random_tick](../../../mcguide/20-玩法开发/15-自定义游戏内容/2-自定义方块/1-JSON组件.html#netease-random-tick)随机tick时 '''
    # event_name = BlockRandomTickServerEvent
    posX        = data["posX"]        # int   方块x坐标
    posY        = data["posY"]        # int   方块y坐标
    posZ        = data["posZ"]        # int   方块z坐标
    blockName   = data["blockName"]   # str   方块名称
    fullName    = data["fullName"]    # str   方块的identifier，包含命名空间及名称
    auxValue    = data["auxValue"]    # int   方块附加值
    dimensionId = data["dimensionId"] # int   实体维度
    return

def BlockRemove(self, data):
    ''' 监听该事件的方块在销毁时触发，可以通过ListenOnBlockRemoveEvent方法进行监听，或者通过json组件[netease:listen_block_remove](../../../mcguide/20-玩法开发/15-自定义游戏内容/2-自定义方块/1-JSON组件.html#netease-listen-block-remove)进行配置 '''
    # event_name = BlockRemoveServerEvent
    posX      = data["x"]         # int   方块位置x
    posY      = data["y"]         # int   方块位置y
    posZ      = data["z"]         # int   方块位置z
    fullName  = data["fullName"]  # str   方块的identifier，包含命名空间及名称
    auxValue  = data["auxValue"]  # int   方块的附加值
    dimension = data["dimension"] # int   该方块所在的维度
    return

def BlockSnowStateChangeAfter(self, data):
    ''' 方块转为含雪或者脱离含雪后触发 '''
    # event_name = BlockSnowStateChangeAfterServerEvent
    dimension    = data["dimension"]    # int   方块维度
    posX         = data["x"]            # int   方块x坐标
    posY         = data["y"]            # int   方块y坐标
    posZ         = data["z"]            # int   方块z坐标
    turnSnow     = data["turnSnow"]     # bool  是否转为含雪，true则转为含雪，false则脱离含雪
    setBlockType = data["setBlockType"] # int   方块进入脱离含雪的原因，参考[SetBlockType]
    return

def BlockSnowStateChange(self, data):
    ''' 方块转为含雪或者脱离含雪前触发 '''
    # event_name = BlockSnowStateChangeServerEvent
    dimension    = data["dimension"]    # int   方块维度
    posX         = data["x"]            # int   方块x坐标
    posY         = data["y"]            # int   方块y坐标
    posZ         = data["z"]            # int   方块z坐标
    turnSnow     = data["turnSnow"]     # bool  是否转为含雪，true则转为含雪，false则脱离含雪
    setBlockType = data["setBlockType"] # int   方块进入脱离含雪的原因，参考[SetBlockType]
    return

def BlockStrengthChanged(self, data):
    ''' 自定义机械元件方块红石信号量发生变化时触发 '''
    # event_name = BlockStrengthChangedServerEvent
    posX        = data["posX"]        # int   方块x坐标
    posY        = data["posY"]        # int   方块y坐标
    posZ        = data["posZ"]        # int   方块z坐标
    blockName   = data["blockName"]   # str   方块的identifier，包含命名空间及名称
    auxValue    = data["auxValue"]    # int   方块附加值
    newStrength = data["newStrength"] # int   变化后的红石信号量
    dimensionId = data["dimensionId"] # int   维度
    return

def ChestBlockTryPairWith(self, data):
    ''' 两个并排的小箱子方块准备组合为一个大箱子方块时 '''
    # event_name = ChestBlockTryPairWithServerEvent
    cancel      = data["cancel"]      # bool  是否允许触发，默认为False，若设为True，可阻止小箱子组合成为一个大箱子
    blockX      = data["blockX"]      # int   小箱子方块x坐标
    blockY      = data["blockY"]      # int   小箱子方块y坐标
    blockZ      = data["blockZ"]      # int   小箱子方块z坐标
    otherBlockX = data["otherBlockX"] # int   将要与之组合的另外一个小箱子方块x坐标
    otherBlockY = data["otherBlockY"] # int   将要与之组合的另外一个小箱子方块y坐标
    otherBlockZ = data["otherBlockZ"] # int   将要与之组合的另外一个小箱子方块z坐标
    dimensionId = data["dimensionId"] # int   维度id
    return

def CommandBlockContainerOpen(self, data):
    ''' 玩家点击命令方块，尝试打开命令方块的设置界面 '''
    # event_name = CommandBlockContainerOpenEvent
    playerId = data["playerId"] # str   玩家实体id
    blockX   = data["blockX"]   # int   命令方块位置x，当isBlock为True时有效
    blockY   = data["blockY"]   # int   命令方块位置y，当isBlock为True时有效
    blockZ   = data["blockZ"]   # int   命令方块位置z，当isBlock为True时有效
    victimId = data["victimId"] # str   命令方块对应的逻辑实体的唯一id，当isBlock为False时有效
    cancel   = data["cancel"]   # bool  修改为True时，可以阻止玩家打开命令方块的设置界面
    return

def CommandBlockUpdate(self, data):
    ''' 玩家尝试修改命令方块的内置命令时 '''
    # event_name = CommandBlockUpdateEvent
    playerId  = data["playerId"]  # str   玩家实体id
    playerUid = data["playerUid"] # int/long 玩家的uid
    command   = data["command"]   # str   企图修改的命令方块中的命令内容字符串
    blockX    = data["blockX"]    # int   命令方块位置x，当isBlock为True时有效
    blockY    = data["blockY"]    # int   命令方块位置y，当isBlock为True时有效
    blockZ    = data["blockZ"]    # int   命令方块位置z，当isBlock为True时有效
    victimId  = data["victimId"]  # str   命令方块对应的逻辑实体的唯一id，当isBlock为False时有效
    cancel    = data["cancel"]    # bool  修改为True时，可以阻止玩家修改命令方块的内置命令
    return

def DestroyBlock(self, data):
    ''' 当方块已经被玩家破坏时触发该事件。 '''
    # event_name = DestroyBlockEvent
    posX        = data["x"]           # int   方块x坐标
    posY        = data["y"]           # int   方块y坐标
    posZ        = data["z"]           # int   方块z坐标
    face        = data["face"]        # int   方块被敲击的面向id，参考[Facing枚举]
    fullName    = data["fullName"]    # str   方块的identifier，包含命名空间及名称
    auxData     = data["auxData"]     # int   方块附加值
    playerId    = data["playerId"]    # str   破坏方块的玩家ID
    dimensionId = data["dimensionId"] # int   维度id
    return

def DirtBlockToGrassBlock(self, data):
    ''' 泥土方块变成草方块时触发 '''
    # event_name = DirtBlockToGrassBlockServerEvent
    dimension = data["dimension"] # int   方块维度
    posX      = data["x"]         # int   方块x坐标
    posY      = data["y"]         # int   方块y坐标
    posZ      = data["z"]         # int   方块z坐标
    return

def EntityPlaceBlockAfter(self, data):
    ''' 当生物成功放置方块后触发 '''
    # event_name = EntityPlaceBlockAfterServerEvent
    posX        = data["x"]           # int   方块x坐标
    posY        = data["y"]           # int   方块y坐标
    posZ        = data["z"]           # int   方块z坐标
    fullName    = data["fullName"]    # str   方块的identifier，包含命名空间及名称
    auxData     = data["auxData"]     # int   方块附加值
    entityId    = data["entityId"]    # str   试图放置方块的生物ID
    dimensionId = data["dimensionId"] # int   维度id
    face        = data["face"]        # int   点击方块的面，参考[Facing枚举]
    return

def FallingBlockBreak(self, data):
    ''' 当下落的方块实体被破坏时，服务端触发该事件 '''
    # event_name = FallingBlockBreakServerEvent
    fallingBlockId = data["fallingBlockId"] # str   下落的方块实体id
    fallingBlockX  = data["fallingBlockX"]  # float 下落的方块实体位置x
    fallingBlockY  = data["fallingBlockY"]  # float 下落的方块实体位置y
    fallingBlockZ  = data["fallingBlockZ"]  # float 下落的方块实体位置z
    blockName      = data["blockName"]      # str   重力方块的identifier，包含命名空间及名称
    fallTickAmount = data["fallTickAmount"] # int   下落的方块实体持续下落了多少tick
    dimensionId    = data["dimensionId"]    # int   下落的方块实体维度id
    cancelDrop     = data["cancelDrop"]     # bool  是否取消方块物品掉落，可以在脚本层中设置
    return

def FallingBlockCauseDamageBefore(self, data):
    ''' 当下落的方块开始计算砸到实体的伤害时，服务端触发该事件 '''
    # event_name = FallingBlockCauseDamageBeforeServerEvent
    fallingBlockId   = data["fallingBlockId"]   # str   下落的方块实体id
    fallingBlockX    = data["fallingBlockX"]    # float 下落的方块实体位置x
    fallingBlockY    = data["fallingBlockY"]    # float 下落的方块实体位置y
    fallingBlockZ    = data["fallingBlockZ"]    # float 下落的方块实体位置z
    blockName        = data["blockName"]        # str   重力方块的identifier，包含命名空间及名称
    dimensionId      = data["dimensionId"]      # int   下落的方块实体维度id
    collidingEntitys = data["collidingEntitys"] # list(str) 当前碰撞到的实体列表id，如果没有的话是None
    fallTickAmount   = data["fallTickAmount"]   # int   下落的方块实体持续下落了多少tick
    fallDistance     = data["fallDistance"]     # float 下落的方块实体持续下落了多少距离
    isHarmful        = data["isHarmful"]        # bool  是否计算对实体的伤害，引擎传来的值由json配置和伤害是否大于0决定，可在脚本层修改传回引擎
    fallDamage       = data["fallDamage"]       # int   对实体的伤害，引擎传来的值距离和json配置决定，可在脚本层修改传回引擎
    return

def FallingBlockReturnHeavyBlock(self, data):
    ''' 当下落的方块实体变回普通重力方块时，服务端触发该事件 '''
    # event_name = FallingBlockReturnHeavyBlockServerEvent
    fallingBlockId    = data["fallingBlockId"]    # int   下落的方块实体id
    blockX            = data["blockX"]            # int   方块位置x
    blockY            = data["blockY"]            # int   方块位置y
    blockZ            = data["blockZ"]            # int   方块位置z
    heavyBlockName    = data["heavyBlockName"]    # str   重力方块的identifier，包含命名空间及名称
    prevHereBlockName = data["prevHereBlockName"] # str   变回重力方块时，原本方块位置的identifier，包含命名空间及名称
    dimensionId       = data["dimensionId"]       # int   下落的方块实体维度id
    fallTickAmount    = data["fallTickAmount"]    # int   下落的方块实体持续下落了多少tick
    return

def FarmBlockToDirtBlock(self, data):
    ''' 耕地退化为泥土时触发 '''
    # event_name = FarmBlockToDirtBlockServerEvent
    dimension    = data["dimension"]    # int   方块维度
    posX         = data["x"]            # int   方块x坐标
    posY         = data["y"]            # int   方块y坐标
    posZ         = data["z"]            # int   方块z坐标
    setBlockType = data["setBlockType"] # int   耕地退化为泥土的原因，参考[SetBlockType]
    return

def GrassBlockToDirtBlock(self, data):
    ''' 草方块变成泥土方块时触发 '''
    # event_name = GrassBlockToDirtBlockServerEvent
    dimension = data["dimension"] # int   方块维度
    posX      = data["x"]         # int   方块x坐标
    posY      = data["y"]         # int   方块y坐标
    posZ      = data["z"]         # int   方块z坐标
    return

def HeavyBlockStartFalling(self, data):
    ''' 当重力方块变为下落的方块实体后，服务端触发该事件 '''
    # event_name = HeavyBlockStartFallingServerEvent
    fallingBlockId = data["fallingBlockId"] # str   下落的方块实体id
    blockX         = data["blockX"]         # int   方块位置x
    blockY         = data["blockY"]         # int   方块位置y
    blockZ         = data["blockZ"]         # int   方块位置z
    blockName      = data["blockName"]      # str   重力方块的identifier，包含命名空间及名称
    dimensionId    = data["dimensionId"]    # int   下落的方块实体维度id
    return

def HopperTryPullIn(self, data):
    ''' 当漏斗上方连接容器后，容器往漏斗开始输入物品时触发，事件仅触发一次 '''
    # event_name = HopperTryPullInServerEvent
    posX        = data["x"]           # int   漏斗位置x
    posY        = data["y"]           # int   漏斗位置y
    posZ        = data["z"]           # int   漏斗位置z
    abovePosX   = data["abovePosX"]   # int   交互的容器位置x
    abovePosY   = data["abovePosY"]   # int   交互的容器位置y
    abovePosZ   = data["abovePosZ"]   # int   交互的容器位置z
    dimensionId = data["dimensionId"] # int   维度id
    canHopper   = data["canHopper"]   # bool  是否允许容器往漏斗加东西(要关闭此交互，需先监听此事件再放置容器)
    return

def HopperTryPullOut(self, data):
    ''' 当漏斗以毗邻的方式连接容器时，即从旁边连接容器时，漏斗向容器开始输出物品时触发，事件仅触发一次 '''
    # event_name = HopperTryPullOutServerEvent
    posX         = data["x"]            # int   漏斗位置x
    posY         = data["y"]            # int   漏斗位置y
    posZ         = data["z"]            # int   漏斗位置z
    attachedPosX = data["attachedPosX"] # int   交互的容器位置x
    attachedPosY = data["attachedPosY"] # int   交互的容器位置y
    attachedPosZ = data["attachedPosZ"] # int   交互的容器位置z
    dimensionId  = data["dimensionId"]  # int   维度id
    canHopper    = data["canHopper"]    # bool  是否允许漏斗往容器加东西(要关闭此交互，需先监听此事件再放置容器)
    return

def OnAfterFallOnBlock(self, data):
    ''' 当实体降落到方块后服务端触发，主要用于力的计算 '''
    # event_name = OnAfterFallOnBlockServerEvent
    entityId  = data["entityId"]  # str   实体id
    posX      = data["posX"]      # float 实体位置x
    posY      = data["posY"]      # float 实体位置y
    posZ      = data["posZ"]      # float 实体位置z
    motionX   = data["motionX"]   # float 瞬时移动X方向的力
    motionY   = data["motionY"]   # float 瞬时移动Y方向的力
    motionZ   = data["motionZ"]   # float 瞬时移动Z方向的力
    blockName = data["blockName"] # str   方块的identifier，包含命名空间及名称
    calculate = data["calculate"] # bool  是否按脚本层传值计算力
    return

def OnBeforeFallOnBlock(self, data):
    ''' 当实体刚降落到方块上时服务端触发，主要用于伤害计算 '''
    # event_name = OnBeforeFallOnBlockServerEvent
    entityId     = data["entityId"]     # str   实体id
    blockX       = data["blockX"]       # int   方块位置x
    blockY       = data["blockY"]       # int   方块位置y
    blockZ       = data["blockZ"]       # int   方块位置z
    blockName    = data["blockName"]    # str   方块的identifier，包含命名空间及名称
    fallDistance = data["fallDistance"] # float 实体下降距离，可在脚本层传给引擎
    cancel       = data["cancel"]       # bool  是否取消引擎对实体下降伤害的计算
    return

def OnEntityInsideBlock(self, data):
    ''' 当实体碰撞盒所在区域有方块时，服务端持续触发 '''
    # event_name = OnEntityInsideBlockServerEvent
    entityId       = data["entityId"]       # str   实体id
    slowdownMultiX = data["slowdownMultiX"] # float 实体移速X方向的减速比例，可在脚本层被修改
    slowdownMultiY = data["slowdownMultiY"] # float 实体移速Y方向的减速比例，可在脚本层被修改
    slowdownMultiZ = data["slowdownMultiZ"] # float 实体移速Z方向的减速比例，可在脚本层被修改
    blockX         = data["blockX"]         # int   方块位置x
    blockY         = data["blockY"]         # int   方块位置y
    blockZ         = data["blockZ"]         # int   方块位置z
    blockName      = data["blockName"]      # str   方块的identifier，包含命名空间及名称
    cancel         = data["cancel"]         # bool  可由脚本层回传True给引擎，阻止触发后续原版逻辑
    return

def OnStandOnBlock(self, data):
    ''' 当实体站立到方块上时服务端持续触发 '''
    # event_name = OnStandOnBlockServerEvent
    entityId    = data["entityId"]    # str   实体id
    dimensionId = data["dimensionId"] # int   实体所在维度id
    posX        = data["posX"]        # float 实体位置x
    posY        = data["posY"]        # float 实体位置y
    posZ        = data["posZ"]        # float 实体位置z
    motionX     = data["motionX"]     # float 瞬时移动X方向的力
    motionY     = data["motionY"]     # float 瞬时移动Y方向的力
    motionZ     = data["motionZ"]     # float 瞬时移动Z方向的力
    blockX      = data["blockX"]      # int   方块位置x
    blockY      = data["blockY"]      # int   方块位置y
    blockZ      = data["blockZ"]      # int   方块位置z
    blockName   = data["blockName"]   # str   方块的identifier，包含命名空间及名称
    cancel      = data["cancel"]      # bool  可由脚本层回传True给引擎，阻止触发后续原版逻辑
    return

def PistonAction(self, data):
    ''' 活塞或者粘性活塞推送/缩回影响附近方块时 '''
    # event_name = PistonActionServerEvent
    cancel           = data["cancel"]           # bool  是否允许触发，默认为False，若设为True，可阻止触发后续的事件
    action           = data["action"]           # str   推送时=expanding；缩回时=retracting
    pistonFacing     = data["pistonFacing"]     # int   活塞的朝向，参考[Facing枚举]
    pistonMoveFacing = data["pistonMoveFacing"] # int   活塞的运动方向，参考[Facing枚举]
    dimensionId      = data["dimensionId"]      # int   活塞方块所在的维度
    pistonX          = data["pistonX"]          # int   活塞方块的x坐标
    pistonY          = data["pistonY"]          # int   活塞方块的y坐标
    pistonZ          = data["pistonZ"]          # int   活塞方块的z坐标
    blockList        = data["blockList"]        # list[(x,y,z),...] 活塞运动影响到产生被移动效果的方块坐标(x,y,z)，均为int类型
    breakBlockList   = data["breakBlockList"]   # list[(x,y,z),...] 活塞运动影响到产生被破坏效果的方块坐标(x,y,z)，均为int类型
    entityList       = data["entityList"]       # list[string,...] 活塞运动影响到产生被移动或被破坏效果的实体的ID列表
    return

def BlockEntityTick(self, data):
    ''' 自定义方块配置了netease:block_entity组件并设tick为true，方块在玩家的模拟距离（新建存档时可以设置，默认为4个区块）内，或者在tickingarea内的时候触发 '''
    # event_name = ServerBlockEntityTickEvent
    blockName = data["blockName"] # str   该方块名称
    dimension = data["dimension"] # int   该方块所在的维度
    posX      = data["posX"]      # int   该方块的x坐标
    posY      = data["posY"]      # int   该方块的y坐标
    posZ      = data["posZ"]      # int   该方块的z坐标
    return

def BlockUse(self, data):
    ''' 玩家右键点击新版自定义方块（或者通过接口AddBlockItemListenForUseEvent增加监听的MC原生游戏方块）时服务端抛出该事件（该事件tick执行，需要注意效率问题）。 '''
    # event_name = ServerBlockUseEvent
    playerId    = data["playerId"]    # str   玩家Id
    blockName   = data["blockName"]   # str   方块的identifier，包含命名空间及名称
    aux         = data["aux"]         # int   方块附加值
    cancel      = data["cancel"]      # bool  设置为True可拦截与方块交互的逻辑。
    posX        = data["x"]           # int   方块x坐标
    posY        = data["y"]           # int   方块y坐标
    posZ        = data["z"]           # int   方块z坐标
    dimensionId = data["dimensionId"] # int   维度id
    return

def EntityTryPlaceBlock(self, data):
    ''' 当生物试图放置方块时触发该事件。 '''
    # event_name = ServerEntityTryPlaceBlockEvent
    posX        = data["x"]           # int   方块x坐标
    posY        = data["y"]           # int   方块y坐标
    posZ        = data["z"]           # int   方块z坐标
    fullName    = data["fullName"]    # str   方块的identifier，包含命名空间及名称
    auxData     = data["auxData"]     # int   方块附加值
    entityId    = data["entityId"]    # str   试图放置方块的生物ID
    dimensionId = data["dimensionId"] # int   维度id
    face        = data["face"]        # int   点击方块的面，参考[Facing枚举]
    cancel      = data["cancel"]      # bool  默认为False，在脚本层设置为True就能取消该方块的放置
    return

def PlaceBlockEntity(self, data):
    ''' 手动放置或通过接口创建含自定义方块实体的方块时触发，此时可向该方块实体中存放数据 '''
    # event_name = ServerPlaceBlockEntityEvent
    blockName = data["blockName"] # str   该方块名称
    dimension = data["dimension"] # int   该方块所在的维度
    posX      = data["posX"]      # int   该方块的x坐标
    posY      = data["posY"]      # int   该方块的y坐标
    posZ      = data["posZ"]      # int   该方块的z坐标
    return

def PlayerTryDestroyBlock(self, data):
    ''' 当玩家即将破坏方块时，服务端线程触发该事件。 '''
    # event_name = ServerPlayerTryDestroyBlockEvent
    posX           = data["x"]              # int   方块x坐标
    posY           = data["y"]              # int   方块y坐标
    posZ           = data["z"]              # int   方块z坐标
    face           = data["face"]           # int   方块被敲击的面向id，参考[Facing枚举]
    fullName       = data["fullName"]       # str   方块的identifier，包含命名空间及名称
    auxData        = data["auxData"]        # int   方块附加值
    playerId       = data["playerId"]       # str   试图破坏方块的玩家ID
    dimensionId    = data["dimensionId"]    # int   维度id
    cancel         = data["cancel"]         # bool  默认为False，在脚本层设置为True就能取消该方块的破坏
    spawnResources = data["spawnResources"] # bool  是否生成掉落物，默认为True，在脚本层设置为False就能取消生成掉落物
    return

def ShearsDestoryBlockBefore(self, data):
    ''' 玩家手持剪刀破坏方块时，有剪刀特殊效果的方块会在服务端线程触发该事件 '''
    # event_name = ShearsDestoryBlockBeforeServerEvent
    blockX       = data["blockX"]       # int   方块位置x
    blockY       = data["blockY"]       # int   方块位置y
    blockZ       = data["blockZ"]       # int   方块位置z
    blockName    = data["blockName"]    # str   方块的identifier，包含命名空间及名称
    auxData      = data["auxData"]      # int   方块附加值
    dropName     = data["dropName"]     # str   触发剪刀效果的掉落物identifier，包含命名空间及名称
    dropCount    = data["dropCount"]    # int   触发剪刀效果的掉落物数量
    playerId     = data["playerId"]     # str   触发剪刀效果的玩家id
    dimensionId  = data["dimensionId"]  # int   玩家触发时的维度id
    cancelShears = data["cancelShears"] # bool  是否取消剪刀效果
    return

def StartDestroyBlock(self, data):
    ''' 玩家开始挖方块时触发。创造模式下不触发。 '''
    # event_name = StartDestroyBlockServerEvent
    pos         = data["pos"]         # tuple(float,float,float) 方块的坐标
    blockName   = data["blockName"]   # str   方块的identifier，包含命名空间及名称
    auxValue    = data["auxValue"]    # int   方块的附加值
    playerId    = data["playerId"]    # str   玩家id
    dimensionId = data["dimensionId"] # int   维度id
    cancel      = data["cancel"]      # bool  修改为True时，可阻止玩家进入挖方块的状态。需要与StartDestroyBlockClientEvent一起修改。
    return

def StepOffBlock(self, data):
    ''' 实体移动离开一个实心方块时触发 '''
    # event_name = StepOffBlockServerEvent
    blockX      = data["blockX"]      # int   方块x坐标
    blockY      = data["blockY"]      # int   方块y坐标
    blockZ      = data["blockZ"]      # int   方块z坐标
    entityId    = data["entityId"]    # str   触发的entity的唯一ID
    blockName   = data["blockName"]   # str   方块的identifier，包含命名空间及名称
    dimensionId = data["dimensionId"] # int   维度id
    return

def StepOnBlock(self, data):
    ''' 实体刚移动至一个新实心方块时触发。 '''
    # event_name = StepOnBlockServerEvent
    cancel      = data["cancel"]      # bool  是否允许触发，默认为False，若设为True，可阻止触发后续物理交互事件
    blockX      = data["blockX"]      # int   方块x坐标
    blockY      = data["blockY"]      # int   方块y坐标
    blockZ      = data["blockZ"]      # int   方块z坐标
    entityId    = data["entityId"]    # str   触发的entity的唯一ID
    blockName   = data["blockName"]   # str   方块的identifier，包含命名空间及名称
    dimensionId = data["dimensionId"] # int   维度id
    return

def ActorAcquiredItem(self, data):
    ''' 玩家获得物品时服务端抛出的事件（有些获取物品方式只会触发客户端事件，有些获取物品方式只会触发服务端事件，在使用时注意一点。） '''
    # event_name = ActorAcquiredItemServerEvent
    actor          = data["actor"]          # str   获得物品玩家实体id
    secondaryActor = data["secondaryActor"] # str   物品给予者玩家实体id，如果不存在给予者的话，这里为空字符串
    acquireMethod  = data["acquireMethod"]  # int   获得物品的方法，详见[ItemAcquisitionMethod枚举]
    return

def ActorUseItem(self, data):
    ''' 玩家使用物品生效之前服务端抛出的事件（比较特殊不走该事件的例子：1）喝牛奶；2）染料对有水的炼药锅使用；3）盔甲架装备盔甲） '''
    # event_name = ActorUseItemServerEvent
    playerId  = data["playerId"]  # str   玩家实体id
    useMethod = data["useMethod"] # int   使用物品的方法，详见[ItemUseMethodEnum枚举]
    return

def ContainerItemChanged(self, data):
    ''' 容器物品变化事件 '''
    # event_name = ContainerItemChangedServerEvent
    pos           = data["pos"]           # tuple(int,int,int)/None 容器坐标
    containerType = data["containerType"] # int   容器类型，类型含义见：[容器类型枚举]
    slot          = data["slot"]          # int   容器槽位
    dimensionId   = data["dimensionId"]   # int   维度id
    return

def CraftItemOutputChange(self, data):
    ''' 玩家从容器拿出生成物品时触发 '''
    # event_name = CraftItemOutputChangeServerEvent
    playerId            = data["playerId"]            # str   玩家实体id
    screenContainerType = data["screenContainerType"] # int   当前界面类型,类型含义见：[容器类型枚举]
    cancel              = data["cancel"]              # bool  是否取消生成物品
    return

def FurnaceBurnFinished(self, data):
    ''' 服务端熔炉烧制触发事件。熔炉, 高炉，烟熏炉烧出物品时触发 '''
    # event_name = FurnaceBurnFinishedServerEvent
    dimensionId = data["dimensionId"] # int   维度id
    posX        = data["posX"]        # float 位置x
    posY        = data["posY"]        # float 位置y
    posZ        = data["posZ"]        # float 位置z
    return

def InventoryItemChanged(self, data):
    ''' 玩家背包物品变化时服务端抛出的事件。 '''
    # event_name = InventoryItemChangedServerEvent
    playerId = data["playerId"] # str   玩家实体id
    slot     = data["slot"]     # int   背包槽位
    return

def ItemReleaseUsing(self, data):
    ''' 释放正在使用的物品时 '''
    # event_name = ItemReleaseUsingServerEvent
    playerId       = data["playerId"]       # str   玩家id
    durationLeft   = data["durationLeft"]   # float 蓄力剩余时间(当物品缺少"minecraft:maxduration"组件时,蓄力剩余时间为负数)
    maxUseDuration = data["maxUseDuration"] # int   最大蓄力时长
    cancel         = data["cancel"]         # bool  设置为True可以取消，需要同时取消客户端事件ItemReleaseUsingClientEvent
    return

def ItemUseAfter(self, data):
    ''' 玩家在使用物品之后服务端抛出的事件。 '''
    # event_name = ItemUseAfterServerEvent
    entityId = data["entityId"] # str   玩家实体id
    return

def ItemUseOnAfter(self, data):
    ''' 玩家在对方块使用物品之后服务端抛出的事件。 '''
    # event_name = ItemUseOnAfterServerEvent
    entityId      = data["entityId"]      # str   玩家实体id
    posX          = data["x"]             # int   方块 x 坐标值
    posY          = data["y"]             # int   方块 y 坐标值
    posZ          = data["z"]             # int   方块 z 坐标值
    face          = data["face"]          # int   点击方块的面，参考[Facing枚举]
    clickX        = data["clickX"]        # float 点击点的x比例位置
    clickY        = data["clickY"]        # float 点击点的y比例位置
    clickZ        = data["clickZ"]        # float 点击点的z比例位置
    blockName     = data["blockName"]     # str   方块的identifier
    blockAuxValue = data["blockAuxValue"] # int   方块的附加值
    dimensionId   = data["dimensionId"]   # int   维度id
    return

def OnCarriedNewItemChanged(self, data):
    ''' 玩家切换主手物品时触发该事件 '''
    # event_name = OnCarriedNewItemChangedServerEvent
    playerId = data["playerId"] # str   玩家 entityId
    return

def OnItemPutInEnchantingModel(self, data):
    ''' 玩家将可附魔物品放到附魔台上时 '''
    # event_name = OnItemPutInEnchantingModelServerEvent
    playerId = data["playerId"] # str   玩家id，参数类型为str
    slotType = data["slotType"] # int   玩家放入物品的EnchantSlotType
    options  = data["options"]  # list  附魔台选项
    change   = data["change"]   # bool  传入True时，附魔台选项会被新传入的options覆盖
    return

def OnNewArmorExchange(self, data):
    ''' 玩家切换盔甲时触发该事件 '''
    # event_name = OnNewArmorExchangeServerEvent
    slot     = data["slot"]     # int   槽位id
    playerId = data["playerId"] # str   玩家 entityId
    return

def OnOffhandItemChanged(self, data):
    ''' 玩家切换副手物品时触发该事件 '''
    # event_name = OnOffhandItemChangedServerEvent
    playerId = data["playerId"] # str   玩家 entityId
    return

def OnPlayerActiveShield(self, data):
    ''' 玩家激活/取消激活盾牌触发的事件。包括玩家持盾进入潜行状态，以及在潜行状态切换盾牌（切换耐久度不同的相同盾牌不会触发） '''
    # event_name = OnPlayerActiveShieldServerEvent
    playerId   = data["playerId"]   # str   玩家Id
    isActive   = data["isActive"]   # bool  True:尝试激活,False:尝试取消激活
    cancelable = data["cancelable"] # bool  是否可以取消。如果玩家在潜行状态切换盾牌，则无法取消
    cancel     = data["cancel"]     # bool  是否取消这次激活
    return

def OnPlayerBlockedByShieldAfter(self, data):
    ''' 玩家使用盾牌抵挡伤害之后触发 '''
    # event_name = OnPlayerBlockedByShieldAfterServerEvent
    playerId = data["playerId"] # str   玩家Id
    sourceId = data["sourceId"] # str   伤害来源实体Id，没有实体返回"-1"
    damage   = data["damage"]   # float 抵挡的伤害数值
    return

def OnPlayerBlockedByShieldBefore(self, data):
    ''' 玩家使用盾牌抵挡伤害之前触发 '''
    # event_name = OnPlayerBlockedByShieldBeforeServerEvent
    playerId = data["playerId"] # str   玩家Id
    sourceId = data["sourceId"] # str   伤害来源实体Id，没有实体返回"-1"
    damage   = data["damage"]   # float 抵挡的伤害数值
    return

def PlayerDropItem(self, data):
    ''' 玩家丢弃物品时触发 '''
    # event_name = PlayerDropItemServerEvent
    playerId     = data["playerId"]     # str   玩家id
    itemEntityId = data["itemEntityId"] # str   物品entityId
    return

def ItemTryUse(self, data):
    ''' 玩家点击右键尝试使用物品时服务端抛出的事件。注：如果需要取消物品的使用需要同时在ClientItemTryUseEvent和ServerItemTryUseEvent中将cancel设置为True才能正确取消。 '''
    # event_name = ServerItemTryUseEvent
    playerId = data["playerId"] # str   玩家id
    cancel   = data["cancel"]   # bool  设为True可取消物品的使用
    return

def ItemUseOn(self, data):
    ''' 玩家在对方块使用物品之前服务端抛出的事件。注：如果需要取消物品的使用需要同时在ClientItemUseOnEvent和ServerItemUseOnEvent中将ret设置为True才能正确取消。 '''
    # event_name = ServerItemUseOnEvent
    entityId      = data["entityId"]      # str   玩家实体id
    posX          = data["x"]             # int   方块 x 坐标值
    posY          = data["y"]             # int   方块 y 坐标值
    posZ          = data["z"]             # int   方块 z 坐标值
    blockName     = data["blockName"]     # str   方块的identifier
    blockAuxValue = data["blockAuxValue"] # int   方块的附加值
    face          = data["face"]          # int   点击方块的面，参考[Facing枚举]
    dimensionId   = data["dimensionId"]   # int   维度id
    clickX        = data["clickX"]        # float 点击点的x比例位置
    clickY        = data["clickY"]        # float 点击点的y比例位置
    clickZ        = data["clickZ"]        # float 点击点的z比例位置
    ret           = data["ret"]           # bool  设为True可取消物品的使用
    return

def PlayerTryTouch(self, data):
    ''' 玩家即将捡起物品时触发 '''
    # event_name = ServerPlayerTryTouchEvent
    playerId    = data["playerId"]    # str   玩家Id
    entityId    = data["entityId"]    # str   物品实体的Id
    cancel      = data["cancel"]      # bool  设置为True时将取消本次拾取
    pickupDelay = data["pickupDelay"] # int   取消拾取后重新设置该物品的拾取cd，小于15帧将视作15帧，大于等于97813帧将视作无法拾取
    return

def ShearsUseToBlockBefore(self, data):
    ''' 实体手持剪刀对方块使用时，有剪刀特殊效果的方块会在服务端线程触发该事件 '''
    # event_name = ShearsUseToBlockBeforeServerEvent
    blockX       = data["blockX"]       # int   方块位置x
    blockY       = data["blockY"]       # int   方块位置y
    blockZ       = data["blockZ"]       # int   方块位置z
    blockName    = data["blockName"]    # str   方块的identifier，包含命名空间及名称
    auxData      = data["auxData"]      # int   方块附加值
    dropName     = data["dropName"]     # str   触发剪刀效果的掉落物identifier，包含命名空间及名称
    dropCount    = data["dropCount"]    # int   触发剪刀效果的掉落物数量
    entityId     = data["entityId"]     # str   触发剪刀效果的实体id，目前仅玩家会触发
    dimensionId  = data["dimensionId"]  # int   玩家触发时的维度id
    cancelShears = data["cancelShears"] # bool  是否取消剪刀效果
    return

def UIContainerItemChanged(self, data):
    ''' 合成容器物品发生变化时触发 '''
    # event_name = UIContainerItemChangedServerEvent
    playerId = data["playerId"] # str   玩家实体id
    slot     = data["slot"]     # int   容器槽位，含义见：[容器类型枚举]
    return

def AttackAnimBegin(self, data):
    ''' 当攻击动作开始时触发 '''
    # event_name = AttackAnimBeginServerEvent
    _id = data["id"] # str   实体id
    return

def AttackAnimEnd(self, data):
    ''' 当攻击动作结束时触发 '''
    # event_name = AttackAnimEndServerEvent
    _id = data["id"] # str   实体id
    return

def JumpAnimBegin(self, data):
    ''' 当跳跃动作开始时触发 '''
    # event_name = JumpAnimBeginServerEvent
    _id = data["id"] # str   实体id
    return

def WalkAnimBegin(self, data):
    ''' 当走路动作开始时触发 '''
    # event_name = WalkAnimBeginServerEvent
    _id = data["id"] # str   实体id
    return

def WalkAnimEnd(self, data):
    ''' 当走路动作结束时触发 '''
    # event_name = WalkAnimEndServerEvent
    _id = data["id"] # str   实体id
    return

def PlayerInventoryOpenScript(self, data):
    ''' 某个客户端打开物品背包界面时触发 '''
    # event_name = PlayerInventoryOpenScriptServerEvent
    playerId   = data["playerId"]   # str   客户端对应的玩家entity的唯一ID
    isCreative = data["isCreative"] # bool  是否是创造模式背包界面
    return

def UrgeShip(self, data):
    ''' 玩家点击商城催促发货按钮时触发该事件 '''
    # event_name = UrgeShipEvent
    playerId = data["playerId"] # str   玩家id
    return
